<?php
/**
 * @package JAMA
 */

/** PHPExcel root directory */
if (!defined('PHPEXCEL_ROOT'))
{
	/**
	 * @ignore
	 */
	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../../');

}


/*
 *	Matrix class
 *
 *	@author Paul Meagher
 *	@author Michael Bommarito
 *	@author Lukasz Karapuda
 *	@author Bartek Matosiuk
 *	@version 1.8
 *	@license PHP v3.0
 *	@see http://math.nist.gov/javanumerics/jama/
 */

class PHPExcel_Shared_JAMA_Matrix {


	const PolymorphicArgumentException = "Invalid argument pattern for polymorphic function.";
	const ArgumentTypeException = "Invalid argument type.";
	const ArgumentBoundsException = "Invalid argument range.";
	const MatrixDimensionException = "Matrix dimensions are not equal.";
	const ArrayLengthException = "Array length must be a multiple of m.";

	/**
	 *    Matrix storage
	 *
	 * @var array
	 * @access public
	 */
	public $A = array();

	/**
	 *    Matrix row dimension
	 *
	 * @var int
	 * @access private
	 */
	private $m;

	/**
	 *    Matrix column dimension
	 *
	 * @var int
	 * @access private
	 */
	private $n;


	/**
	 *    Polymorphic constructor
	 *
	 *    As PHP has no support for polymorphic constructors, we hack our own sort of polymorphism using func_num_args, func_get_arg, and gettype. In essence, we're just implementing a simple RTTI filter and calling the appropriate constructor.
	 */
	public function __construct() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				//Rectangular matrix - m x n initialized from 2D array
				case 'array':
					$this->m = count($args[0]);
					$this->n = count($args[0][0]);
					$this->A = $args[0];
					break;
				//Square matrix - n x n
				case 'integer':
					$this->m = $args[0];
					$this->n = $args[0];
					$this->A = array_fill(0, $this->m, array_fill(0, $this->n, 0));
					break;
				//Rectangular matrix - m x n
				case 'integer,integer':
					$this->m = $args[0];
					$this->n = $args[1];
					$this->A = array_fill(0, $this->m, array_fill(0, $this->n, 0));
					break;
				//Rectangular matrix - m x n initialized from packed array
				case 'array,integer':
					$this->m = $args[1];
					if ($this->m != 0)
					{
						$this->n = count($args[0]) / $this->m;
					}
					else
					{
						$this->n = 0;
					}
					if (($this->m * $this->n) == count($args[0]))
					{
						for ($i = 0; $i < $this->m; ++$i)
						{
							for ($j = 0; $j < $this->n; ++$j)
							{
								$this->A[$i][$j] = $args[0][$i + $j * $this->m];
							}
						}
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArrayLengthException);
					}
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function __construct()


	/**
	 *    getArray
	 *
	 * @return array Matrix array
	 */
	public function getArray() {
		return $this->A;
	} //	function getArray()


	/**
	 *    getRowDimension
	 *
	 * @return int Row dimension
	 */
	public function getRowDimension() {
		return $this->m;
	} //	function getRowDimension()


	/**
	 *    getColumnDimension
	 *
	 * @return int Column dimension
	 */
	public function getColumnDimension() {
		return $this->n;
	} //	function getColumnDimension()


	/**
	 *    get
	 *
	 *    Get the i,j-th element of the matrix.
	 *
	 * @param int $i Row position
	 * @param int $j Column position
	 *
	 * @return mixed Element (int/float/double)
	 */
	public function get($i = null, $j = null) {
		return $this->A[$i][$j];
	} //	function get()


	/**
	 *    getMatrix
	 *
	 *    Get a submatrix
	 *
	 * @param int $i0 Initial row index
	 * @param int $iF Final row index
	 * @param int $j0 Initial column index
	 * @param int $jF Final column index
	 *
	 * @return Matrix Submatrix
	 */
	public function getMatrix() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				//A($i0...; $j0...)
				case 'integer,integer':
					list($i0, $j0) = $args;
					if ($i0 >= 0)
					{
						$m = $this->m - $i0;
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException);
					}
					if ($j0 >= 0)
					{
						$n = $this->n - $j0;
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException);
					}
					$R = new PHPExcel_Shared_JAMA_Matrix($m, $n);
					for ($i = $i0; $i < $this->m; ++$i)
					{
						for ($j = $j0; $j < $this->n; ++$j)
						{
							$R->set($i, $j, $this->A[$i][$j]);
						}
					}

					return $R;
					break;
				//A($i0...$iF; $j0...$jF)
				case 'integer,integer,integer,integer':
					list($i0, $iF, $j0, $jF) = $args;
					if (($iF > $i0) && ($this->m >= $iF) && ($i0 >= 0))
					{
						$m = $iF - $i0;
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException);
					}
					if (($jF > $j0) && ($this->n >= $jF) && ($j0 >= 0))
					{
						$n = $jF - $j0;
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException);
					}
					$R = new PHPExcel_Shared_JAMA_Matrix($m + 1, $n + 1);
					for ($i = $i0; $i <= $iF; ++$i)
					{
						for ($j = $j0; $j <= $jF; ++$j)
						{
							$R->set($i - $i0, $j - $j0, $this->A[$i][$j]);
						}
					}

					return $R;
					break;
				//$R = array of row indices; $C = array of column indices
				case 'array,array':
					list($RL, $CL) = $args;
					if (count($RL) > 0)
					{
						$m = count($RL);
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException);
					}
					if (count($CL) > 0)
					{
						$n = count($CL);
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException);
					}
					$R = new PHPExcel_Shared_JAMA_Matrix($m, $n);
					for ($i = 0; $i < $m; ++$i)
					{
						for ($j = 0; $j < $n; ++$j)
						{
							$R->set($i - $i0, $j - $j0, $this->A[$RL[$i]][$CL[$j]]);
						}
					}

					return $R;
					break;
				//$RL = array of row indices; $CL = array of column indices
				case 'array,array':
					list($RL, $CL) = $args;
					if (count($RL) > 0)
					{
						$m = count($RL);
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException);
					}
					if (count($CL) > 0)
					{
						$n = count($CL);
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException);
					}
					$R = new PHPExcel_Shared_JAMA_Matrix($m, $n);
					for ($i = 0; $i < $m; ++$i)
					{
						for ($j = 0; $j < $n; ++$j)
						{
							$R->set($i, $j, $this->A[$RL[$i]][$CL[$j]]);
						}
					}

					return $R;
					break;
				//A($i0...$iF); $CL = array of column indices
				case 'integer,integer,array':
					list($i0, $iF, $CL) = $args;
					if (($iF > $i0) && ($this->m >= $iF) && ($i0 >= 0))
					{
						$m = $iF - $i0;
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException);
					}
					if (count($CL) > 0)
					{
						$n = count($CL);
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException);
					}
					$R = new PHPExcel_Shared_JAMA_Matrix($m, $n);
					for ($i = $i0; $i < $iF; ++$i)
					{
						for ($j = 0; $j < $n; ++$j)
						{
							$R->set($i - $i0, $j, $this->A[$RL[$i]][$j]);
						}
					}

					return $R;
					break;
				//$RL = array of row indices
				case 'array,integer,integer':
					list($RL, $j0, $jF) = $args;
					if (count($RL) > 0)
					{
						$m = count($RL);
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException);
					}
					if (($jF >= $j0) && ($this->n >= $jF) && ($j0 >= 0))
					{
						$n = $jF - $j0;
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentBoundsException);
					}
					$R = new PHPExcel_Shared_JAMA_Matrix($m, $n + 1);
					for ($i = 0; $i < $m; ++$i)
					{
						for ($j = $j0; $j <= $jF; ++$j)
						{
							$R->set($i, $j - $j0, $this->A[$RL[$i]][$j]);
						}
					}

					return $R;
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function getMatrix()


	/**
	 *    checkMatrixDimensions
	 *
	 *    Is matrix B the same size?
	 *
	 * @param Matrix $B Matrix B
	 *
	 * @return boolean
	 */
	public function checkMatrixDimensions($B = null) {
		if ($B instanceof PHPExcel_Shared_JAMA_Matrix)
		{
			if (($this->m == $B->getRowDimension()) && ($this->n == $B->getColumnDimension()))
			{
				return true;
			}
			else
			{
				throw new PHPExcel_Calculation_Exception(self::MatrixDimensionException);
			}
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
		}
	} //	function checkMatrixDimensions()


	/**
	 *    set
	 *
	 *    Set the i,j-th element of the matrix.
	 *
	 * @param int   $i Row position
	 * @param int   $j Column position
	 * @param mixed $c Int/float/double value
	 *
	 * @return mixed Element (int/float/double)
	 */
	public function set($i = null, $j = null, $c = null) {
		// Optimized set version just has this
		$this->A[$i][$j] = $c;
	} //	function set()


	/**
	 *    identity
	 *
	 *    Generate an identity matrix.
	 *
	 * @param int $m Row dimension
	 * @param int $n Column dimension
	 *
	 * @return Matrix Identity matrix
	 */
	public function identity($m = null, $n = null) {
		return $this->diagonal($m, $n, 1);
	} //	function identity()


	/**
	 *    diagonal
	 *
	 *    Generate a diagonal matrix
	 *
	 * @param int   $m Row dimension
	 * @param int   $n Column dimension
	 * @param mixed $c Diagonal value
	 *
	 * @return Matrix Diagonal matrix
	 */
	public function diagonal($m = null, $n = null, $c = 1) {
		$R = new PHPExcel_Shared_JAMA_Matrix($m, $n);
		for ($i = 0; $i < $m; ++$i)
		{
			$R->set($i, $i, $c);
		}

		return $R;
	} //	function diagonal()


	/**
	 *    getMatrixByRow
	 *
	 *    Get a submatrix by row index/range
	 *
	 * @param int $i0 Initial row index
	 * @param int $iF Final row index
	 *
	 * @return Matrix Submatrix
	 */
	public function getMatrixByRow($i0 = null, $iF = null) {
		if (is_int($i0))
		{
			if (is_int($iF))
			{
				return $this->getMatrix($i0, 0, $iF + 1, $this->n);
			}
			else
			{
				return $this->getMatrix($i0, 0, $i0 + 1, $this->n);
			}
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
		}
	} //	function getMatrixByRow()


	/**
	 *    getMatrixByCol
	 *
	 *    Get a submatrix by column index/range
	 *
	 * @param int $i0 Initial column index
	 * @param int $iF Final column index
	 *
	 * @return Matrix Submatrix
	 */
	public function getMatrixByCol($j0 = null, $jF = null) {
		if (is_int($j0))
		{
			if (is_int($jF))
			{
				return $this->getMatrix(0, $j0, $this->m, $jF + 1);
			}
			else
			{
				return $this->getMatrix(0, $j0, $this->m, $j0 + 1);
			}
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
		}
	} //	function getMatrixByCol()


	/**
	 *    transpose
	 *
	 *    Tranpose matrix
	 *
	 * @return Matrix Transposed matrix
	 */
	public function transpose() {
		$R = new PHPExcel_Shared_JAMA_Matrix($this->n, $this->m);
		for ($i = 0; $i < $this->m; ++$i)
		{
			for ($j = 0; $j < $this->n; ++$j)
			{
				$R->set($j, $i, $this->A[$i][$j]);
			}
		}

		return $R;
	} //	function transpose()


	/**
	 *    trace
	 *
	 *    Sum of diagonal elements
	 *
	 * @return float Sum of diagonal elements
	 */
	public function trace() {
		$s = 0;
		$n = min($this->m, $this->n);
		for ($i = 0; $i < $n; ++$i)
		{
			$s += $this->A[$i][$i];
		}

		return $s;
	} //	function trace()


	/**
	 *    uminus
	 *
	 *    Unary minus matrix -A
	 *
	 * @return Matrix Unary minus matrix
	 */
	public function uminus() {
	} //	function uminus()


	/**
	 *    plus
	 *
	 *    A + B
	 *
	 * @param mixed $B Matrix/Array
	 *
	 * @return Matrix Sum
	 */
	public function plus() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				case 'object':
					if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix)
					{
						$M = $args[0];
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
					}
					break;
				case 'array':
					$M = new PHPExcel_Shared_JAMA_Matrix($args[0]);
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
			$this->checkMatrixDimensions($M);
			for ($i = 0; $i < $this->m; ++$i)
			{
				for ($j = 0; $j < $this->n; ++$j)
				{
					$M->set($i, $j, $M->get($i, $j) + $this->A[$i][$j]);
				}
			}

			return $M;
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function plus()


	/**
	 *    plusEquals
	 *
	 *    A = A + B
	 *
	 * @param mixed $B Matrix/Array
	 *
	 * @return Matrix Sum
	 */
	public function plusEquals() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				case 'object':
					if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix)
					{
						$M = $args[0];
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
					}
					break;
				case 'array':
					$M = new PHPExcel_Shared_JAMA_Matrix($args[0]);
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
			$this->checkMatrixDimensions($M);
			for ($i = 0; $i < $this->m; ++$i)
			{
				for ($j = 0; $j < $this->n; ++$j)
				{
					$validValues = true;
					$value = $M->get($i, $j);
					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && (!is_numeric($this->A[$i][$j])))
					{
						$this->A[$i][$j] = trim($this->A[$i][$j], '"');
						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]);
					}
					if ((is_string($value)) && (strlen($value) > 0) && (!is_numeric($value)))
					{
						$value = trim($value, '"');
						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($value);
					}
					if ($validValues)
					{
						$this->A[$i][$j] += $value;
					}
					else
					{
						$this->A[$i][$j] = PHPExcel_Calculation_Functions::NaN();
					}
				}
			}

			return $this;
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function plusEquals()


	/**
	 *    minus
	 *
	 *    A - B
	 *
	 * @param mixed $B Matrix/Array
	 *
	 * @return Matrix Sum
	 */
	public function minus() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				case 'object':
					if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix)
					{
						$M = $args[0];
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
					}
					break;
				case 'array':
					$M = new PHPExcel_Shared_JAMA_Matrix($args[0]);
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
			$this->checkMatrixDimensions($M);
			for ($i = 0; $i < $this->m; ++$i)
			{
				for ($j = 0; $j < $this->n; ++$j)
				{
					$M->set($i, $j, $M->get($i, $j) - $this->A[$i][$j]);
				}
			}

			return $M;
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function minus()


	/**
	 *    minusEquals
	 *
	 *    A = A - B
	 *
	 * @param mixed $B Matrix/Array
	 *
	 * @return Matrix Sum
	 */
	public function minusEquals() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				case 'object':
					if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix)
					{
						$M = $args[0];
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
					}
					break;
				case 'array':
					$M = new PHPExcel_Shared_JAMA_Matrix($args[0]);
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
			$this->checkMatrixDimensions($M);
			for ($i = 0; $i < $this->m; ++$i)
			{
				for ($j = 0; $j < $this->n; ++$j)
				{
					$validValues = true;
					$value = $M->get($i, $j);
					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && (!is_numeric($this->A[$i][$j])))
					{
						$this->A[$i][$j] = trim($this->A[$i][$j], '"');
						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]);
					}
					if ((is_string($value)) && (strlen($value) > 0) && (!is_numeric($value)))
					{
						$value = trim($value, '"');
						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($value);
					}
					if ($validValues)
					{
						$this->A[$i][$j] -= $value;
					}
					else
					{
						$this->A[$i][$j] = PHPExcel_Calculation_Functions::NaN();
					}
				}
			}

			return $this;
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function minusEquals()


	/**
	 *    arrayTimes
	 *
	 *    Element-by-element multiplication
	 *    Cij = Aij * Bij
	 *
	 * @param mixed $B Matrix/Array
	 *
	 * @return Matrix Matrix Cij
	 */
	public function arrayTimes() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				case 'object':
					if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix)
					{
						$M = $args[0];
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
					}
					break;
				case 'array':
					$M = new PHPExcel_Shared_JAMA_Matrix($args[0]);
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
			$this->checkMatrixDimensions($M);
			for ($i = 0; $i < $this->m; ++$i)
			{
				for ($j = 0; $j < $this->n; ++$j)
				{
					$M->set($i, $j, $M->get($i, $j) * $this->A[$i][$j]);
				}
			}

			return $M;
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function arrayTimes()


	/**
	 *    arrayTimesEquals
	 *
	 *    Element-by-element multiplication
	 *    Aij = Aij * Bij
	 *
	 * @param mixed $B Matrix/Array
	 *
	 * @return Matrix Matrix Aij
	 */
	public function arrayTimesEquals() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				case 'object':
					if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix)
					{
						$M = $args[0];
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
					}
					break;
				case 'array':
					$M = new PHPExcel_Shared_JAMA_Matrix($args[0]);
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
			$this->checkMatrixDimensions($M);
			for ($i = 0; $i < $this->m; ++$i)
			{
				for ($j = 0; $j < $this->n; ++$j)
				{
					$validValues = true;
					$value = $M->get($i, $j);
					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && (!is_numeric($this->A[$i][$j])))
					{
						$this->A[$i][$j] = trim($this->A[$i][$j], '"');
						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]);
					}
					if ((is_string($value)) && (strlen($value) > 0) && (!is_numeric($value)))
					{
						$value = trim($value, '"');
						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($value);
					}
					if ($validValues)
					{
						$this->A[$i][$j] *= $value;
					}
					else
					{
						$this->A[$i][$j] = PHPExcel_Calculation_Functions::NaN();
					}
				}
			}

			return $this;
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function arrayTimesEquals()


	/**
	 *    arrayRightDivide
	 *
	 *    Element-by-element right division
	 *    A / B
	 *
	 * @param Matrix $B Matrix B
	 *
	 * @return Matrix Division result
	 */
	public function arrayRightDivide() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				case 'object':
					if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix)
					{
						$M = $args[0];
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
					}
					break;
				case 'array':
					$M = new PHPExcel_Shared_JAMA_Matrix($args[0]);
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
			$this->checkMatrixDimensions($M);
			for ($i = 0; $i < $this->m; ++$i)
			{
				for ($j = 0; $j < $this->n; ++$j)
				{
					$validValues = true;
					$value = $M->get($i, $j);
					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && (!is_numeric($this->A[$i][$j])))
					{
						$this->A[$i][$j] = trim($this->A[$i][$j], '"');
						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]);
					}
					if ((is_string($value)) && (strlen($value) > 0) && (!is_numeric($value)))
					{
						$value = trim($value, '"');
						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($value);
					}
					if ($validValues)
					{
						if ($value == 0)
						{
							//	Trap for Divide by Zero error
							$M->set($i, $j, '#DIV/0!');
						}
						else
						{
							$M->set($i, $j, $this->A[$i][$j] / $value);
						}
					}
					else
					{
						$M->set($i, $j, PHPExcel_Calculation_Functions::NaN());
					}
				}
			}

			return $M;
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function arrayRightDivide()


	/**
	 *    arrayRightDivideEquals
	 *
	 *    Element-by-element right division
	 *    Aij = Aij / Bij
	 *
	 * @param mixed $B Matrix/Array
	 *
	 * @return Matrix Matrix Aij
	 */
	public function arrayRightDivideEquals() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				case 'object':
					if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix)
					{
						$M = $args[0];
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
					}
					break;
				case 'array':
					$M = new PHPExcel_Shared_JAMA_Matrix($args[0]);
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
			$this->checkMatrixDimensions($M);
			for ($i = 0; $i < $this->m; ++$i)
			{
				for ($j = 0; $j < $this->n; ++$j)
				{
					$this->A[$i][$j] = $this->A[$i][$j] / $M->get($i, $j);
				}
			}

			return $M;
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function arrayRightDivideEquals()


	/**
	 *    arrayLeftDivide
	 *
	 *    Element-by-element Left division
	 *    A / B
	 *
	 * @param Matrix $B Matrix B
	 *
	 * @return Matrix Division result
	 */
	public function arrayLeftDivide() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				case 'object':
					if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix)
					{
						$M = $args[0];
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
					}
					break;
				case 'array':
					$M = new PHPExcel_Shared_JAMA_Matrix($args[0]);
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
			$this->checkMatrixDimensions($M);
			for ($i = 0; $i < $this->m; ++$i)
			{
				for ($j = 0; $j < $this->n; ++$j)
				{
					$M->set($i, $j, $M->get($i, $j) / $this->A[$i][$j]);
				}
			}

			return $M;
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function arrayLeftDivide()


	/**
	 *    arrayLeftDivideEquals
	 *
	 *    Element-by-element Left division
	 *    Aij = Aij / Bij
	 *
	 * @param mixed $B Matrix/Array
	 *
	 * @return Matrix Matrix Aij
	 */
	public function arrayLeftDivideEquals() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				case 'object':
					if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix)
					{
						$M = $args[0];
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
					}
					break;
				case 'array':
					$M = new PHPExcel_Shared_JAMA_Matrix($args[0]);
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
			$this->checkMatrixDimensions($M);
			for ($i = 0; $i < $this->m; ++$i)
			{
				for ($j = 0; $j < $this->n; ++$j)
				{
					$this->A[$i][$j] = $M->get($i, $j) / $this->A[$i][$j];
				}
			}

			return $M;
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function arrayLeftDivideEquals()


	/**
	 *    times
	 *
	 *    Matrix multiplication
	 *
	 * @param mixed $n Matrix/Array/Scalar
	 *
	 * @return Matrix Product
	 */
	public function times() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				case 'object':
					if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix)
					{
						$B = $args[0];
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
					}
					if ($this->n == $B->m)
					{
						$C = new PHPExcel_Shared_JAMA_Matrix($this->m, $B->n);
						for ($j = 0; $j < $B->n; ++$j)
						{
							for ($k = 0; $k < $this->n; ++$k)
							{
								$Bcolj[$k] = $B->A[$k][$j];
							}
							for ($i = 0; $i < $this->m; ++$i)
							{
								$Arowi = $this->A[$i];
								$s = 0;
								for ($k = 0; $k < $this->n; ++$k)
								{
									$s += $Arowi[$k] * $Bcolj[$k];
								}
								$C->A[$i][$j] = $s;
							}
						}

						return $C;
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(JAMAError(MatrixDimensionMismatch));
					}
					break;
				case 'array':
					$B = new PHPExcel_Shared_JAMA_Matrix($args[0]);
					if ($this->n == $B->m)
					{
						$C = new PHPExcel_Shared_JAMA_Matrix($this->m, $B->n);
						for ($i = 0; $i < $C->m; ++$i)
						{
							for ($j = 0; $j < $C->n; ++$j)
							{
								$s = "0";
								for ($k = 0; $k < $C->n; ++$k)
								{
									$s += $this->A[$i][$k] * $B->A[$k][$j];
								}
								$C->A[$i][$j] = $s;
							}
						}

						return $C;
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(JAMAError(MatrixDimensionMismatch));
					}

					return $M;
					break;
				case 'integer':
					$C = new PHPExcel_Shared_JAMA_Matrix($this->A);
					for ($i = 0; $i < $C->m; ++$i)
					{
						for ($j = 0; $j < $C->n; ++$j)
						{
							$C->A[$i][$j] *= $args[0];
						}
					}

					return $C;
					break;
				case 'double':
					$C = new PHPExcel_Shared_JAMA_Matrix($this->m, $this->n);
					for ($i = 0; $i < $C->m; ++$i)
					{
						for ($j = 0; $j < $C->n; ++$j)
						{
							$C->A[$i][$j] = $args[0] * $this->A[$i][$j];
						}
					}

					return $C;
					break;
				case 'float':
					$C = new PHPExcel_Shared_JAMA_Matrix($this->A);
					for ($i = 0; $i < $C->m; ++$i)
					{
						for ($j = 0; $j < $C->n; ++$j)
						{
							$C->A[$i][$j] *= $args[0];
						}
					}

					return $C;
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function times()


	/**
	 *    power
	 *
	 *    A = A ^ B
	 *
	 * @param mixed $B Matrix/Array
	 *
	 * @return Matrix Sum
	 */
	public function power() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				case 'object':
					if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix)
					{
						$M = $args[0];
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
					}
					break;
				case 'array':
					$M = new PHPExcel_Shared_JAMA_Matrix($args[0]);
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
			$this->checkMatrixDimensions($M);
			for ($i = 0; $i < $this->m; ++$i)
			{
				for ($j = 0; $j < $this->n; ++$j)
				{
					$validValues = true;
					$value = $M->get($i, $j);
					if ((is_string($this->A[$i][$j])) && (strlen($this->A[$i][$j]) > 0) && (!is_numeric($this->A[$i][$j])))
					{
						$this->A[$i][$j] = trim($this->A[$i][$j], '"');
						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($this->A[$i][$j]);
					}
					if ((is_string($value)) && (strlen($value) > 0) && (!is_numeric($value)))
					{
						$value = trim($value, '"');
						$validValues &= PHPExcel_Shared_String::convertToNumberIfFraction($value);
					}
					if ($validValues)
					{
						$this->A[$i][$j] = pow($this->A[$i][$j], $value);
					}
					else
					{
						$this->A[$i][$j] = PHPExcel_Calculation_Functions::NaN();
					}
				}
			}

			return $this;
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function power()


	/**
	 *    concat
	 *
	 *    A = A & B
	 *
	 * @param mixed $B Matrix/Array
	 *
	 * @return Matrix Sum
	 */
	public function concat() {
		if (func_num_args() > 0)
		{
			$args = func_get_args();
			$match = implode(",", array_map('gettype', $args));

			switch ($match)
			{
				case 'object':
					if ($args[0] instanceof PHPExcel_Shared_JAMA_Matrix)
					{
						$M = $args[0];
					}
					else
					{
						throw new PHPExcel_Calculation_Exception(self::ArgumentTypeException);
					}
				case 'array':
					$M = new PHPExcel_Shared_JAMA_Matrix($args[0]);
					break;
				default:
					throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
					break;
			}
			$this->checkMatrixDimensions($M);
			for ($i = 0; $i < $this->m; ++$i)
			{
				for ($j = 0; $j < $this->n; ++$j)
				{
					$this->A[$i][$j] = trim($this->A[$i][$j], '"') . trim($M->get($i, $j), '"');
				}
			}

			return $this;
		}
		else
		{
			throw new PHPExcel_Calculation_Exception(self::PolymorphicArgumentException);
		}
	} //	function concat()


	/**
	 *    Solve A*X = B.
	 *
	 * @param Matrix $B Right hand side
	 *
	 * @return Matrix ... Solution if A is square, least squares solution otherwise
	 */
	public function solve($B) {
		if ($this->m == $this->n)
		{
			$LU = new PHPExcel_Shared_JAMA_LUDecomposition($this);

			return $LU->solve($B);
		}
		else
		{
			$QR = new QRDecomposition($this);

			return $QR->solve($B);
		}
	} //	function solve()


	/**
	 *    Matrix inverse or pseudoinverse.
	 *
	 * @return Matrix ... Inverse(A) if A is square, pseudoinverse otherwise.
	 */
	public function inverse() {
		return $this->solve($this->identity($this->m, $this->m));
	} //	function inverse()


	/**
	 *    det
	 *
	 *    Calculate determinant
	 *
	 * @return float Determinant
	 */
	public function det() {
		$L = new PHPExcel_Shared_JAMA_LUDecomposition($this);

		return $L->det();
	} //	function det()


} //	class PHPExcel_Shared_JAMA_Matrix
